using System;
using System.Collections.Generic;
using System.Text;
using System.Collections.ObjectModel;
using Mpi.Common.Collections;

namespace Xeml.Document.Contracts
{

    public interface IPlainOntologyHandler : IOntologyHandler
    {

        IEnumerable<IOntologyTerm> Terms
        {
            get;
        }

        IOntologyTerm Find(Term param);

        IOntologyTerm Find(string termId);

    }

    public interface IVariableOntologyHandler : IOntologyHandler
    {

        IEnumerable<IVariableOntologyTerm> Terms
        {
            get;
        }

        IVariableOntologyTerm Find(Term param);

        IVariableOntologyTerm Find(string termId);

    }

    public interface IDynamicOntologyHandler : IOntologyHandler
    {

        IEnumerable<IDynamicOntologyTerm> Terms
        {
            get;
        }

        IDynamicOntologyTerm Find(Term param);

        IDynamicOntologyTerm Find(string termId);

    }

    //public interface IOrganismStructureOntologyHandler : IOntologyHandler
    //{

    //    IEnumerable<IMaterialSupervisor> Supervisors
    //    {
    //        get;
    //    }

    //    IMaterialSupervisor Find(Material mat);

    //    IMaterialSupervisor Find(string termId);

    //}



    public interface ITermSupervisor<T> where T : class, ISupervisableTerm
    {

        string TermId
        {
            get;
        }

        IEnumerable<T> SupervisedObjects
        {
            get;
        }

        string Name
        {
            get;
            set;
        }

        string NameSpace
        {
            get;
            set;
        }

        string NameSpaceAlias
        {
            get;
            set;
        }

        string Definition
        {
            get;
            set;
        }
    
        T EmitDefaultObject(bool supervised);

        void Supervise(T t);

        void RejectSupervison(T t);

        void ValidateSupervisedProperties();

        void PushSupervisedProperties();

        event System.EventHandler<ValidationMessage> Validation;

    }

    public interface IOntologyTerm
    {

        string TermId
        {
            get;
        }

        IEnumerable<Term> SupervisedObjects
        {
            get;
        }

        Term Prototype
        {
            get;
        }

        string Definition
        {
            get;
            set;
        }

        TermAttributeCollection Attributes
        {
            get;
        }

       
        Term EmitDefaultObject(bool supervised);

        void Supervise(Term t);

        void RejectSupervison(Term t);

        void ValidateSupervisedProperties();

        void PushSupervisedProperties();

        event System.EventHandler<ValidationMessage> Validation;

    }

    public class TermAttribute
    {
        public string Name { get; private set; }
        public string Value { get; private set; }
        private  string Id
        {
            get
            { return string.Concat(Name , ":", Value); }
        }
        public TermAttribute(string name, string val)
        {
            Name = name;
            Value = val;
        }

        public override string ToString()
        {
            return Id;
        }
    }

    public class TermAttributeCollection : ObservableIdCollectionBase<TermAttribute, string>
    {


        protected override string GetIdentifiere(TermAttribute item)
        {
            return item.Name;
        }

        protected override void SetOwner(TermAttribute item)
        {
          
        }

        protected override void RemoveOwner(TermAttribute item)
        {
            
        }
    }
    //public interface IVariableSupervisor : ITermSupervisor<Variable>
    //{

        

      
    //    string[] GroupLevels
    //    {
    //        get;
            
    //    }

    //     string Group
    //    {
    //        get;

    //    }

    //    string GroupPath
    //    {
    //        get;

    //    }

       

    //    Uri CommunityUrl
    //    {
    //        get;

    //    }


    //    string[] Contexts
    //    {
    //        get;
    //    }

    //    int ContextCount
    //    {
    //        get;
    //    }

    //    int RecommendationLevel
    //    {
    //        get;         
    //    }

    //    bool HasDefaultValue(string context);

        

    //    bool HasDefaultCycle(string context);

    //    bool HasDefaultUnit(string context);

    //    string DefaultUnitName(string context);

    //    string DefaultUnitSymbol(string context);

    //    List<KeyValuePair<string, string>> ListUnits(string context);

    //    VariableDataTypes GetDataType(string context);

    //    decimal? GetMin(string context);

    //    decimal? GetMax(string context);

    //    List<KeyValuePair<string,string>> GetEnums(string context);

    //    DynamicValue DefaultValue(string context);

    //    Cycle DefaultCycle(string context);

    //    DynamicValue DefaultValue(string context, TimeSpan time);

    //    Cycle DefaultCycle(string context, TimeSpan time);


        
        
    //}

    public interface IDynamicOntologyTerm : IVariableOntologyTerm
    {
          
        bool HasDefaultCycle(string context);          

        Cycle DefaultCycle(string context);

        DynamicValue DefaultValue(string context, TimeSpan time);

        Cycle DefaultCycle(string context, TimeSpan time);

    }
    public interface IVariableOntologyTerm : IOntologyTerm
    {

        string[] Contexts
        {
            get;
        }

        int ContextCount
        {
            get;
        }

       

        bool HasDefaultValue(string context);

        bool HasDefaultUnit(string context);

        string DefaultUnitName(string context);

        string DefaultUnitSymbol(string context);

        List<KeyValuePair<string, string>> ListUnits(string context);

        VariableDataTypes GetDataType(string context);

        decimal? GetMin(string context);

        decimal? GetMax(string context);

        List<KeyValuePair<string, string>> GetEnums(string context);

        ValueBase DefaultValue(string context);
    }

    //public interface IMaterialSupervisor : ITermSupervisor<Material>
    //{

     
    //}

    public interface ISupervisableTerm
    {
        string TermId
        {
            get;
        }
    }
}
